
/**************************************************************
 *
 * Copyright ? 2009，北京福富软件技术股份有限公司
 * All Rights Reserved.
 * ------------------------------------------------------------
 * 文件名称：CommonUtil.java
 * 文件摘要：公共工具包
 * 初始版本：V2.0.0
 * 初始作者：Linz
 * 完成日期：2009-11-26
 *
 **************************************************************/
package com.util;

import sun.misc.BASE64Decoder;

import java.io.*;
import java.lang.reflect.Method;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**************************************************************************
 *
 * 类名：CommonUtil<br>
 * <br>
 * 功能：公共工具包<br>
 * <br>
 * 作者：Linz 2009-11-26<br>
 * <br>
 * 属性列表：<br>
 * 		无<br>
 * <br>
 * 方法列表：<br>
 * 		public static String toGBK(String str)<br>
 * 		public static String toGBK(String str, boolean isGBK)<br>
 * 		...<br>
 * <br>
 * 修改记录：<br>
 * 		日期				修改人			修改说明<br>
 *
 **************************************************************************/
public class CommonUtil
{

	/**************************************************************************
	 *
	 * 函数名：NVL(Object obj)<br>
	 * <br>
	 * 功能：把Object转为字符串格式，如果为null，转为""<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		Object obj -> 对象<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 字符串格式<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String NVL(Object obj)
	{
		return obj==null ? "" : obj.toString();
	}


	/**************************************************************************
	 *
	 * 函数名：toGBK(String str)<br>
	 * <br>
	 * 功能：把字符串转换成GBK内码<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String str -> 需要转换的String<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换内码的String<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String toGBK(String str)
	{
		if (str==null) { return null; }
		try
		{
			return new String(str.getBytes("ISO_8859_1"), "GBK");
		}
		catch (Exception e)
		{
			return null;
		}
	}


	/**************************************************************************
	 *
	 * 函数名：toGBK(String str, boolean isGBK)<br>
	 * <br>
	 * 功能：根据是否中文标志，把字符串转换成GBK内码<br>
	 *      如isGBK=true，不转换，主要用于出库显示<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String str -> 需要转换的String<br>
	 * 		boolean isGBK -> 是否中文标志<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换内码的String<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String toGBK(String str, boolean isGBK)
	{
		return isGBK ? str : toGBK(str);
	}


	/**************************************************************************
	 *
	 * 函数名：toISO(String str)<br>
	 * <br>
	 * 功能：把字符串转换成ISO内码<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String str -> 需要转换的String<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换内码的String<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String toISO(String str)
	{
		if (str==null) { return null; }
		try
		{
			return new String(str.getBytes("GBK"), "ISO_8859_1");
		}
		catch (Exception e)
		{
			return null;
		}
	}


	/**************************************************************************
	 *
	 * 函数名：toIso(String str, boolean isGBK)<br>
	 * <br>
	 * 功能：根据是否中文标志，把字符串转换成GBK内码<br>
	 *      如isGBK=true，不转换，主要用于入库<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String str -> 需要转换的String<br>
	 * 		boolean isGBK -> 是否中文标志<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换内码的String<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String toISO(String str, boolean isGBK)
	{
		return isGBK ? str : toISO(str);
	}


	/**************************************************************************
	 *
	 * 函数名：ipStringToLong(String ipStr)<br>
	 * <br>
	 * 功能：把ip地址串转换成长整形数<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String ipStr -> 需要转换的ip地址<br>
	 * <br>
	 * 返回值：<br>
	 * 		long -> 转换后的长整形ip<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static long ipStringToLong(String ip)
	{
		if (ip==null || "".equals(ip) || "0".equals(ip)) { return 0; }
		try
		{
			String[] ipArray = ip.split("\\.");
			if (ipArray.length != 4) { return -1; }
			for (int i=0; i<ipArray.length; i++)
			{
				if (ipArray[i].length()>3 || Long.parseLong(ipArray[i])<0 || Long.parseLong(ipArray[i])>255)
				{
					return -1;
				}
			}
			long lg1 = Long.parseLong(ipArray[0])*256*256*256;
			long lg2 = Long.parseLong(ipArray[1])*256*256;
			long lg3 = Long.parseLong(ipArray[2])*256;
			long lg4 = Long.parseLong(ipArray[3]);
			return lg1 + lg2 + lg3 + lg4;
		}
		catch (Exception e)
		{
			return -1;
		}
	}
	public static long ipStringToLong1(String ip)
	{
		if (ip==null || "".equals(ip) || "0".equals(ip)) { return 0; }
		try
		{
			String[] ipArray = ip.split("\\.");
			if (ipArray.length != 4) { return -1; }
			for (int i=0; i<ipArray.length; i++)
			{
				if (ipArray[i].length()>3 || Long.parseLong(ipArray[i])<0 || Long.parseLong(ipArray[i])>255)
				{
					return -1;
				}
			}
			long lg1 = Long.parseLong(ipArray[3])*256*256*256;
			long lg2 = Long.parseLong(ipArray[2])*256*256;
			long lg3 = Long.parseLong(ipArray[1])*256;
			long lg4 = Long.parseLong(ipArray[0]);
			return lg1 + lg2 + lg3 + lg4;
		}
		catch (Exception e)
		{
			return -1;
		}
	}
 


	/**************************************************************************
	 *
	 * 函数名：longToIpString(long ip)<br>
	 * <br>
	 * 功能：把长整形ip转为字符串地址<br>
	 * <br>
	 * 作者：Linz 2008-12-24<br>
	 * <br>
	 * 参数表：<br>
	 * 		long ip -> 需要转换的ip地址<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换后的字符串ip<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String longToIpString(long ip)
	{
		if (ip==0) { return "0.0.0.0"; }
		if (ip<0)  { return ""; }
		try
		{
			long ip1 = ip / (256*256*256);
			long ip2 = (ip-ip1*256*256*256) / (256*256);
			long ip3 = (ip-ip1*256*256*256-ip2*256*256) / 256;
			long ip4 = ip % 256;
			return "" + ip4 + "." + ip3 + "." + ip2+ "." + ip1;
		}
		catch (Exception e)
		{
			return "";
		}
	}
	public static String longToIpString1(long ip)
	{
		if (ip==0) { return "0.0.0.0"; }
		if (ip<0)  { return ""; }
		try
		{
			long ip1 = ip / (256*256*256);
			long ip2 = (ip-ip1*256*256*256) / (256*256);
			long ip3 = (ip-ip1*256*256*256-ip2*256*256) / 256;
			long ip4 = ip % 256;
			return "" + ip1 + "." + ip2 + "." + ip3+ "." + ip4;
		}
		catch (Exception e)
		{
			return "";
		}
	}


	/**************************************************************************
	 *
	 * 函数名：isIpString(String ipStr)<br>
	 * <br>
	 * 功能：判断传入的字符串是否是正确的IP地址<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String ipStr -> 传入的字符串<br>
	 * <br>
	 * 返回值：<br>
	 * 		boolean -> 是否为IP, true->是, false->否<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static boolean isIpString(String ipStr)
	{
		if (ipStr==null || "".equals(ipStr)) { return false; }
		String regex = "(((2[0-4]\\d)|(25[0-5]))|(1\\d{2})|([1-9]\\d)|(\\d))"
			+ "[.]"
			+ "(((2[0-4]\\d)|(25[0-5]))|(1\\d{2})|([1-9]\\d)|(\\d))"
			+ "[.]"
			+ "(((2[0-4]\\d)|(25[0-5]))|(1\\d{2})|([1-9]\\d)|(\\d))"
			+ "[.]"
			+ "(((2[0-4]\\d)|(25[0-5]))|(1\\d{2})|([1-9]\\d)|(\\d))";
		Pattern   p  = Pattern.compile(regex);
		Matcher   m  = p.matcher(ipStr);
		return m.matches();
	}


	/**************************************************************************
	 *
	 * 函数名：getMd5Encrypt(String value)<br>
	 * <br>
	 * 功能：将给定的字符串转为MD5的加密字符串<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String value -> 加密前的字符串<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 加密后的字符串<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String getMd5Encrypt(String value)
	{
		if (value==null) { return null; }
		//定义十六进制序列
		String hexSequence = "0123456789abcdef";

		//将参数的字符串转为字节数组
		byte[] preparedMessage = value.getBytes();

		//生成实现MD5摘要算法的 MessageDigest 对象
		MessageDigest md = null;

		try
		{
			md = MessageDigest.getInstance("MD5");
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}

		//使用指定的字节串更新此摘要
		md.update(preparedMessage);

		//完成哈希算法
		byte[] newMessage = md.digest();

		//返回
		int length = newMessage.length;
		char[] message = new char[length*2];
		int index = 0;
		for (int i=0; i<length; i++)
		{
			message[index++] = hexSequence.charAt(newMessage[i]>>>4 & 0xf);
			message[index++] = hexSequence.charAt(newMessage[i] & 0xf);
		}
		return new String(message);
	}


	/**************************************************************************
	 *
	 * 函数名：public static String reverseString(String str)<br>
	 * <br>
	 * 功能：字符串反转<br>
	 * <br>
	 * 作者：Linz 2009-11-26<br>
	 * <br>
	 * 参数表：<br>
	 * 		String str -> 传入的字符串<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 反转后的字符串<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String reverseString(String str)
	{
		byte[] bt = str.getBytes();
		int length = bt.length;
		int half = bt.length/2;
		byte temp = 0;
		for (int i=0; i<half; i++) {
			temp  = bt[i];
			bt[i] = bt[length-1-i];
			bt[length-1-i] = temp;
		}
		return new String(bt);
	}

	/**************************************************************************
	 *
	 * 函数名：public String longToFlowString(long fl)<br>
	 * <br>
	 * 功能：将流量的整形数转为字符串<br>
	 * <br>
	 * 作者：Linz 2010-09-09<br>
	 * <br>
	 * 参数表：<br>
	 * 		long fl -> 流量值(字节)<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换后的字符串<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 * 		2010-09-16		Linz			流量(Byte)转化为后保留小数点后2位<br>
	 *
	 **************************************************************************/
	public static String longToFlowString(long fl)
	{
		if (fl<1024)
		{
			return fl + " Byte";
		}
		if (fl<1024*1024)
		{
			return new DecimalFormat("#.##").format(fl*1.0/1024)+" KB";
		}
		if (fl<1024*1024*1024)
		{
			return new DecimalFormat("#.##").format(fl*1.0/(1024*1024))+" MB";
		}
		else
		{
			return new DecimalFormat("#.##").format(fl*1.0/(1024*1024*1024))+" GB";
		}
	}


	/**************************************************************************
	 *
	 * 函数名：public String longToTimeString(long fl)<br>
	 * <br>
	 * 功能：将时间的整形数转为字符串<br>
	 * <br>
	 * 作者：ChenKQ 2012-04-12<br>
	 * <br>
	 * 参数表：<br>
	 * 		long fl -> 时间值(ms)<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换后的字符串<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String longToTimeString(long fl)
	{
		if (fl<1000)
		{
			return fl + " 毫秒";
		}
		if (fl<1000*60)
		{
			return new DecimalFormat("#.##").format(fl*1.0/1000)+" 秒";
		}
		if (fl<1000*60*60)
		{
			return new DecimalFormat("#.##").format(fl*1.0/(1000*60))+" 分";
		}
		else
		{
			return new DecimalFormat("#.##").format(fl*1.0/(1000*60*60))+" 小时";
		}
	}

	/**************************************************************************
	 *
	 * 函数名：getTimestamp()<br>
	 * <br>
	 * 功能：取时间数保存图片名用<br>
	 * <br>
	 * 作者：ChenKQ 2011-04-12<br>
	 * <br>
	 * 参数表：<br>
	 * 		无<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 10位时间数<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String getTimestamp() {
		Date date = new Date();
		long time = date.getTime();
		String dateline = time + "";
		dateline = dateline.substring(0, 10);
		return dateline;
	}


	/**************************************************************************
	 *
	 * 函数名：public static List<String> regStringToUnitList(String regStr)<br>
	 * <br>
	 * 功能：将检索中的规则串拆分成元素集合，每个元素为最小的细分<br>
	 * <br>
	 * 作者：Linz 2010-09-09<br>
	 * <br>
	 * 参数表：<br>
	 * 		String regStr -> 查询规则串<br>
	 * <br>
	 * 返回值：<br>
	 * 		List -> 拆分后的集合<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static List<String> regStringToUnitList(String regStr)
	{
		if (null==regStr || "".equals(regStr))
		{
			return null;
		}
		List<String> outList = new ArrayList<String>();
		//更新说明：如果规则串只有一个字符，直接返回
		if (regStr.length()==1)
		{
			outList.add(regStr);
			return outList;
		}
		//其它的进行解析
		char c    = '0';
		int left  = -1;		//文字出现的左位置
		int right = -1;		//文字出现的右位置
		int flag  = 0;		//表示文字被截过的标志
		String ss = "";		//临时字符串

		for (int i=0; i<regStr.length(); i++)
		{
			c = regStr.charAt(i);
			if (c=='(')
			{
				outList.add(String.valueOf(c));
				if (left>-1)
				{
					right = i;
					ss    = regStr.substring(left, right);
					outList.add(ss);
					left  = -1;
					right = -1;
					flag  = 1;
				}
				continue;
			}
			if (c==')')
			{
				if (left>-1)
				{
					right = i;
					ss    = regStr.substring(left, right);
					outList.add(ss);
					left  = -1;
					right = -1;
					flag  = 1;
				}
				outList.add(String.valueOf(c));
				continue;
			}
			if (c=='|')
			{
				if (left>-1)
				{
					right = i;
					ss    = regStr.substring(left, right);
					outList.add(ss);
					left  = -1;
					right = -1;
					flag  = 1;
				}
				outList.add("or");
				continue;
			}
			if (c=='&')
			{
				if (left>-1)
				{
					right = i;
					ss    = regStr.substring(left, right);
					outList.add(ss);
					left  = -1;
					right = -1;
					flag  = 1;
				}
				outList.add("and");
				continue;
			}
			if (i==regStr.length()-1)
			{
				if (left>-1)
				{
					right = i;
					ss    = regStr.substring(left);
					outList.add(ss);
					left  = -1;
					right = -1;
					continue;
				}
				if (left==-1 && flag==1)
				{
					ss    = regStr.substring(i);
					outList.add(ss);
					left  = -1;
					right = -1;
					continue;
				}
			}
			if (left==-1)
			{
				left = i;
			}
		}
		return outList;
	}



	/**************************************************************************
	 *
	 * 函数名：public static void deleteFile(File file)<br>
	 * <br>
	 * 功能：删除掉这个文件夹包括文件下的子文件<br>
	 * <br>
	 * 作者：yaozhx 2012-02-23<br>
	 * <br>
	 * 参数表：<br>
	 * 		File file -> 文件<br>
	 * <br>
	 * 返回值：<br>
	 * 		<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/


	public static void deleteFile(File file){
		   if(file.exists()){                    //判断文件是否存在
		    if(file.isFile()){                    //判断是否是文件
		     file.delete();                       //delete()方法 是删除的意思;
		    }else if(file.isDirectory()){              //否则如果它是一个目录
		     File files[] = file.listFiles();               //声明目录下所有的文件 files[];
		     for(int i=0;i<files.length;i++){            //遍历目录下所有的文件
		    	 CommonUtil.deleteFile(files[i]);         //把每个文件 用这个方法进行迭代
		     }
		    }
		    file.delete();
		   }else{
		    System.out.println("所删除的文件不存在！"+'\n');
		   }
		}



	/**************************************************************************
	 *
	 * 函数名：public String longToFlowString1(long fl)<br>
	 * <br>
	 * 功能：将流量的整形数转为字符串（M-->G）<br>
	 * <br>
	 * 作者：YUYI 2012-06-14<br>
	 * <br>
	 * 参数表：<br>
	 * 		long fl -> 流量值(M)<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换后的字符串<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String longToFlowString1(long fl)
	{
		if (fl<1024)
		{
			return fl + " MB";
		}
		else
		{
			return new DecimalFormat("#.##").format(fl*1.0/1024)+" GB";
		}
	}

	/**************************************************************************
	 *
	 * 函数名：public String doubleToFlowString1(long fl)<br>
	 * <br>
	 * 功能：将流量的长浮点形数转为字符串（M-->G）<br>
	 * <br>
	 * 作者：YUYI 2012-06-14<br>
	 * <br>
	 * 参数表：<br>
	 * 		Double fl -> 流量值(M)<br>
	 * <br>
	 * 返回值：<br>
	 * 		String -> 转换后的字符串<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	public static String doubleToFlowString1(double fl)
	{
		if (fl<1024)
		{
			return fl + " MB";
		}
		else
		{
			return new DecimalFormat("#.##").format(fl*1.0/1024)+" GB";
		}
	}

	public static Date StringToFullDate(String str)
	{
		if (str==null) { return null; }
		try
		{
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			Date outDate = formatter.parse(str);
			return outDate;
		}
		catch (Exception e)
		{
			return null;
		}
	}
	public static String DateToFullString(Date inDate)
	{
		try
		{
			if (inDate==null) { return null; }
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String outDateStr = formatter.format(inDate);
			return outDateStr;
		}
		catch (Exception e)
		{
			return null;
		}
	}
	
	
	public static String DateToFullStringMillis(int millis)
	{
		try
		{
			Date date = new Date();
			date.setTime(date.getTime() + millis * 1000);
			if (date==null) { return null; }
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String outDateStr = formatter.format(date);
			return outDateStr;
		}
		catch (Exception e)
		{
			return null;
		}
	}
	
	public static String DateToSimpleString(Date inDate)
	{
		try
		{
			if (inDate==null) { return null; }
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
			String outDateStr = formatter.format(inDate);
			return outDateStr;
		}
		catch (Exception e)
		{
			return null;
		}
	}
	
	public static String DateToString(Date inDate)
	{
		try
		{
			if (inDate==null) { return null; }
			SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddhhmmss");
			String outDateStr = formatter.format(inDate);
			return outDateStr;
		}
		catch (Exception e)
		{
			return null;
		}
	}
	

	/**
	 * 
	 * 作者： ZhengYan <br />
	 * 
	 * 方法名：GetObjectDebugFormatString	 <br />
	 * 功能：获取对象调试信息格式化描述字符串 <br />
	 * 参数列表： <br />
	 * 		@param obj 要描述的对象
	 * 		@return 调试信息格式化描述字符串 <br />
	 * 日期：2013-3-14 <br />
	 */
	public static String GetObjectDebugFormatString(Object obj)
	{
		Class type = obj.getClass();
		
		StringBuffer result = new StringBuffer();
		
		Method[] methods = type.getMethods();
		
		result.append("{\t");
		
		try
		{
			for(Method m : methods)
			{
				String name = m.getName();
				if((name.indexOf("get") == 0 
						&& !name.equals("getClass"))
						)
				{
					String n = name.substring(3, 4).toLowerCase() + name.substring(4);
					
					
					
					Object resultObj = m.invoke(obj, null);
					String _tmp = "";
					
					if(resultObj != null && resultObj.getClass().isArray())
					{
						for(Object o : (Object[])resultObj)
						{
							_tmp += ";" + o;
						}
					}
					else
						_tmp = resultObj + "";
					result.append(n + "==>"+ _tmp + ";\t");
				}
				else if((name.indexOf("is") == 0))
				{
					String n = name.substring(2, 3).toLowerCase() + name.substring(3);
					result.append(n + "==>"+ m.invoke(obj, null) + ";\t");
				}
			}
		}catch(Exception e)
		{
			e.printStackTrace();
			System.out.println("属性获取异常！！！");
		}
		result.append("}\r\n");
		
		return result.toString();
	}
	
	/**************************************************************************
	 *
	 * 函数名：	public static String getAgent(String user_agent)<br>
	 * <br>
	 * 功能：根据参数来转变终端类型<br>
	 * <br>
	 * 作者：yaozhx 2014-02-14<br>
	 * <br>
	 * 参数表：<br>
	 * 		user_agentl->参数<br>
	 * <br>
	 * 返回值：<br>
	 * 		agent -> 转换后的取得的终端类型<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 *
	 **************************************************************************/
	
	public static String getAgent(String user_agent){
		String agent="";
		user_agent = user_agent.toUpperCase();
		if(user_agent.contains("ANDROID")){
			 if(user_agent.contains("MOBILE"))
			 {
					agent="ANDROID_MB";
			 }else 
			 {
					agent="ANDROID_PC";
			 }
		}else if(user_agent.contains("WINDOWS")){
			agent="PC";
		}else if(user_agent.contains("IPHONE")){
			agent="IPHONE";
		}else if(user_agent.contains("IPAD")){
			agent="IPAD";
		}else{
			agent="其它";
		}
		return agent;
	}
	
	/**************************************************************************
	 * 
	 * 函数名：public static Date getDateOfInterval(Date date, int n, int type)<br>
	 * <br>
	 * 功能：根据类型取得距离指定时间相差N个间隔的时间<br>
	 * <br>
	 * 作者：Linz 2013<br>
	 * <br>
	 * 参数表：<br>
	 * 		Date inDate -> 日期<br>
	 * 		int  n 	 	-> 时间间隔，N可以为正整数或负整数<br>
	 * 		int  type 	-> 时间类型1:年2:月3:日4:时5:分6:秒<br>
	 * <br>
	 * 返回值：<br>
	 * 		Date -> 时间对象<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 * 
	 **************************************************************************/
	public static Date getDateOfInterval(Date inDate, int interval, int type)
	{
		if (inDate==null)		return null;
		if (type<1 || type>6) 	return null;
		try {
			Calendar cd = Calendar.getInstance();
			cd.setTime(inDate);
			switch(type)
			{
				case 1:
					cd.add(Calendar.YEAR, interval);
					break;
				case 2:
					cd.add(Calendar.MONTH, interval);
					break;
				case 3:
					cd.add(Calendar.DATE, interval);
					break;
				case 4:
					cd.add(Calendar.HOUR, interval);
					break;
				case 5:
					cd.add(Calendar.MINUTE, interval);
					break;
				case 6:
					cd.add(Calendar.SECOND, interval);
					break;
				default:
					return null;
			}
			return cd.getTime();
		}
		catch (Exception e) {
			return null;
		}
	}
	
	/**************************************************************************
	 *
	 * 函数名：	public static String sha1Encrypt(String Passwd)<br>
	 * <br>
	 * 功能：根据参数来进行加密《语音接口使用》<br>
	 * <br>
	 * 作者：yaozhx 2014-02-14<br>
	 * <br>
	 * 参数表：<br>
	 * 		Passwd->参数<br>
	 * <br>
	 * 返回值：<br>
	 * 		result -> 加密后的字段<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 * @throws NoSuchAlgorithmException 
	 *
	 **************************************************************************/
	public static String sha1Encrypt(String Passwd) throws NoSuchAlgorithmException {
	    MessageDigest alg = MessageDigest.getInstance("SHA-1");
	    alg.update(Passwd.getBytes());
	    byte[] bts = alg.digest();
	    String result = "";
	    String tmp = "";
	    for (int i = 0; i < bts.length; i++) {
	        tmp = (Integer.toHexString(bts[i] & 0xFF));
	        if (tmp.length() == 1) result += "0";
	          result += tmp;
	    }
	    return result;
	}
	
	/**************************************************************************
	 *
	 * 函数名：	public static String encryptionMD(String plain)<br>
	 * <br>
	 * 功能：MD5 32位小写密文<br>
	 * <br>
	 * 作者：yaozhx 2014-02-14<br>
	 * <br>
	 * 参数表：<br>
	 * 		Passwd->参数<br>
	 * <br>
	 * 返回值：<br>
	 * 		result -> 加密后的字段<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 * @throws NoSuchAlgorithmException 
	 *
	 **************************************************************************/
	
	 public static String encryptionMD(String plain) {
	  String re_md5 = new String();
	  try {
	   MessageDigest md = MessageDigest.getInstance("MD5");
	   md.update(plain.getBytes());
	   byte b[] = md.digest();

	   int i;
	   StringBuffer buf = new StringBuffer("");
	   for (int offset = 0; offset < b.length; offset++) {
	    i = b[offset];
	    if (i < 0)
	     i += 256;
	    if (i < 16)
	    buf.append("0");
	    buf.append(Integer.toHexString(i));
	   }

	   re_md5 = buf.toString();

	  } catch (NoSuchAlgorithmException e) {
	   e.printStackTrace();
	  }
	  return re_md5;
	 }
	
	
	
	public static int DateToSimpleInt(Date inDate) 
	{
		String outDateStr = "";
		if (inDate != null) 
		{
			SimpleDateFormat formatter = new SimpleDateFormat("HHmm");
			outDateStr = formatter.format(inDate);
		}
		
		return  Integer.parseInt(outDateStr);
	}
	
	/**************************************************************************
	 *
	 * 函数名：	public static String eryDecoder(String plain)<br>
	 * <br>
	 * 功能：BASE64解密<br>
	 * <br>
	 * 作者：yaozhx 2014-02-14<br>
	 * <br>
	 * 参数表：<br>
	 * 		Passwd->参数<br>
	 * <br>
	 * 返回值：<br>
	 * 		result -> 加密后的字段<br>
	 * <br>
	 * 修改记录：<br>
	 * 		日期				修改人			修改说明<br>
	 * @throws NoSuchAlgorithmException 
	 *
	 **************************************************************************/
	 public static String eryDecoder(String cipter){

	        if (cipter == null || cipter.equals(""))
	          throw new RuntimeException("值不能为空..");
	        try{
	          BASE64Decoder base64 = new BASE64Decoder();
	          byte[] decode = base64.decodeBuffer(cipter);
	          return new String(decode);
	        }catch(IOException rd){}
	       return "";
	  }
	
	/************************************************************************
	 * 
	 * 函数名：copyFile <br>
	 * <br>
	 * 功能： 复制文件<br>
	 * 作者：yuyi 2013-10-24<br>
	 * <br> 
	 * 参数表：<br>
	 * 
	 * @param inputStream
	 * @param destfile
	 * @throws IOException
	 * <br>
	 * <br>
	 *             返回值：<br>
	 *             void <br>
	 *             修改记录：<br>
	 *             日期 修改人 修改说明<br>
	 * 
	 **************************************************************************/
	 public static void copyFile(InputStream inputStream, String destfile)
			throws IOException
	{
		OutputStream out_stream = new FileOutputStream(destfile);
		byte[] buffer = new byte[1024];
		int len = 0;
		while ((len = inputStream.read(buffer)) != -1)
		{
			out_stream.write(buffer, 0, len);
		}
		out_stream.flush();
		out_stream.close();
		inputStream.close();
	}
	 /**************************************************************************
		 * 
		 * 函数名：IntToString(int  i)<br>
		 * <br>
		 * 功能：INT转成String 000001<br>
		 * <br>
		 * 作者：Linz 2006-12-27<br>
		 * <br>
		 * 参数表：<br>
		 * 		int<br>
		 * <br>
		 * 返回值：<br>
		 * 		String  -> <br>
		 * <br>
		 * 修改记录：<br>
		 * 		日期				修改人			修改说明<br>
		 * 
		 **************************************************************************/
	    public static String  IntToString(int i)
	    {
		    if(i>999999)
		    {
		    	i=1;
		    }
			String str = null;  //转换成字符串
			 // 1~9之间
			if (i >0 && i < 10)
			{  
				str = "00000" + i; 
			}
			// 10~99之间
			else if (i <100)
			{
				str = "0000" + i; 
			}
			 // 100~999之间
			else if (i < 1000)
			{   
				str = "000" + i;
			}
			// 1000~9999之间
			else if (i < 10000) {  
				str = "00"+i; 
			}
			// 1000~9999之间
			else if (i < 100000) {  
				str = "0"+i; 
			}
			// 1000~9999之间
			else if (i<1000000)
			{
				str = String.valueOf(i);
			}
			
		     return str;
	    }
	    /**************************************************************************
		 * 
		 * 函数名：LongToString(int  i)<br>
		 * <br>
		 * 功能：Long转成String 000001<br>
		 * <br>
		 * 作者：Linz 2006-12-27<br>
		 * <br>
		 * 参数表：<br>
		 * 		int<br>
		 * <br>
		 * 返回值：<br>
		 * 		String  -> <br>
		 * <br>
		 * 修改记录：<br>
		 * 		日期				修改人			修改说明<br>
		 * 
		 **************************************************************************/
	    public static String  LongToString(Long i)
	    {
		    if(i>999999999)
		    {
		    	i=(long) 1;
		    }
			String str = null;  //转换成字符串
			 // 1~9之间
			if (i >0 && i < 10)
			{  
				str = "000000000" + i; 
			}
			// 10~99之间
			else if (i <100)
			{
				str = "00000000" + i; 
			}
			 // 100~999之间
			else if (i < 1000)
			{   
				str = "0000000" + i;
			}
			// 1000~9999之间
			else if (i < 10000) {  
				str = "000000"+i; 
			}
			// 10000~99999之间
			else if (i < 100000) {  
				str = "00000"+i; 
			}
			// 100000~999999之间
			else if (i < 1000000) {  
				str = "0000"+i; 
			}
			// 1000000~9999999之间
			else if (i < 10000000) {  
				str = "000"+i; 
			}
			// 10000000~99999999之间
			else if (i < 100000000) {  
				str = "00"+i; 
			}
			// 100000000~999999999之间
			else if (i < 1000000000) {  
				str = "0"+i; 
			}
			
			// 1000~9999之间
			else if (i<10000000000L)
			{
				str = String.valueOf(i);
			}
		     return str;
	    }
   
	    /**************************************************************************
		 * 
		 * 函数名：IntToString(int  i)<br>
		 * <br>
		 * 功能：INT转成String 000001<br>
		 * <br>
		 * 作者：Linz 2006-12-27<br>
		 * <br>
		 * 参数表：<br>
		 * 		int<br>
		 * <br>
		 * 返回值：<br>
		 * 		String  -> <br>
		 * <br>
		 * 修改记录：<br>
		 * 		日期				修改人			修改说明<br>
		 * 
		 **************************************************************************/
	    public static String  IntToString_1(int i)
	    {
		    if(i>95)
		    {
		    	i=1;
		    }
			String str = null;  //转换成字符串
			 // 1~9之间
			if (i >0 && i < 10)
			{  
				str = "00" + i; 
			}
			// 10~99之间
			else if (i <100)
			{
				str = "0" + i; 
			}			
		     return str;
	    }    
	    /**      
	     *  复制单个文件    
	     *    * @param oldPath String 
	     *    原文件路径 如：c:/fqf.txt   
	     *       * @param newPath String 
	     *       复制后路径 如：f:/fqf.txt    
	     *         * @return boolean    
	     *           */  
	    public static void copyFile(String oldPath, String newPath) {     
	    	try {            int bytesum = 0;     
	    	int byteread = 0;         
	    	File oldfile = new File(oldPath);     
	    	if (oldfile.exists()) { //文件存在时        
	    		InputStream inStream = new FileInputStream(oldPath); //读入原文件        
	    		FileOutputStream fs = new FileOutputStream(newPath);     
	    		byte[] buffer = new byte[1444];        
	    		int length;      
	    		while ( (byteread = inStream.read(buffer)) != -1) {     
	    			bytesum += byteread; //字节数 文件大小             
	    			fs.write(buffer, 0, byteread);                }     
	    		    inStream.close();        
	    		    }       
	    	     }      
	    	 catch (Exception e) {      
	    		System.out.println("复制单个文件操作出错");       
	    		e.printStackTrace();   
	    		}    
	    	}  

	    /**************************************************************************
		 *
		 * 函数名：	public  static String getLateTenMin(String endtime)<br>
		 * <br>
		 * 功能：与某个时间值作和<br>
		 * <br>
		 * 作者：supa 2015-03-24<br>
		 * <br>
		 * 参数表：<br>
		 * 		starttime->时间<br>
		 * 		
		 * <br>
		 * 返回值：<br>
		 * 		result -> 时间结果字符串<br>
		 * <br>
		 * 修改记录：<br>
		 * 		日期				修改人			修改说明<br>
		 * 
		 **************************************************************************/
		public static String getLateTenMin(String endtime,int min){
			String outDateStr="";
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			Date d;
			try {
				d = df.parse(endtime);
				long tamp = d.getTime();
				long tampten = tamp+min*60*1000;
				Date date = new Date();
				date.setTime(tampten);
				outDateStr = CommonUtil.DateToFullString(date);
			} catch (ParseException e) {
				e.printStackTrace();
			}
			return outDateStr;
		}
	    
		/**************************************************************************
		 *
		 * 函数名：	 public static boolean isMobileNO(String mobiles)<br>
		 * <br>
		 * 功能：判断是为手机号<br>
		 * <br>
		 * 作者：YaoZhx 2015-5-10<br>
		 * <br>
		 * 参数表：<br>
		 * 		mobileNumber->手机号<br>
		 * 		
		 * <br>
		 * 返回值：<br>
		 * 		PhoneBelong -> 归属性的BEAN<br>
		 * <br>
		 * 修改记录：<br>
		 * 		日期				修改人			修改说明<br>
		 * 
		 **************************************************************************/
		 public static boolean isMobileNO(String mobiles) {
			Pattern p = Pattern
					.compile("^((13[0-9])|(15[^4,\\D])|(18[0-9])|(17[0-9]))\\d{8}$");
			Matcher m = p.matcher(mobiles);
			return m.matches();
		 }

	    /**************************************************************************
		 *
		 * 函数名：	public  static PhoneBelong queryMobileArea(String mobileNumber)<br>
		 * <br>
		 * 功能：查询手机号的归属BEAN<br>
		 * <br>
		 * 作者：YaoZhx 2015-5-10<br>
		 * <br>
		 * 参数表：<br>
		 * 		mobileNumber->手机号<br>
		 * 		
		 * <br>
		 * 返回值：<br>
		 * 		PhoneBelong -> 归属性的BEAN<br>
		 * <br>
		 * 修改记录：<br>
		 * 		日期				修改人			修改说明<br>
		 * 
		 **************************************************************************/


		public static void main(String[] args) {
			
			

			
			
		}
}
